home *** CD-ROM | disk | FTP | other *** search
/ Dynamic HTML Construction Kit / Dynamic HTML Construction Kit.iso / earthlink / nscomm / java40.jar / netscape / util / ClassTable.class (.txt) < prev    next >
Encoding:
Java Class File  |  1997-11-03  |  14.4 KB  |  1,137 lines
  1. package netscape.util;
  2.  
  3. import java.io.IOException;
  4. import java.io.InputStream;
  5. import java.io.OutputStream;
  6.  
  7. public class ClassTable {
  8.    Archive archive;
  9.    String className;
  10.    int classCount;
  11.    String[] classNames;
  12.    int[] classVersions;
  13.    int fieldCount;
  14.    byte[] fieldTypes;
  15.    String[] fieldNames;
  16.    IdHashtable columnForField;
  17.    int rowCapacity;
  18.    int rowCount;
  19.    Object[] fieldColumns;
  20.    int tableId;
  21.    boolean uniqueStrings;
  22.  
  23.    public ClassTable(Archive var1) {
  24.       this.archive = var1;
  25.    }
  26.  
  27.    public ClassTable(Archive var1, ClassInfo var2) {
  28.       this(var1);
  29.       this.className = var2.className();
  30.       this.classCount = var2.classCount();
  31.       this.classNames = var2.classNames();
  32.       this.classVersions = var2.classVersions();
  33.       this.fieldCount = var2.fieldCount();
  34.       this.fieldTypes = var2.fieldTypes();
  35.       this.fieldNames = var2.fieldNames();
  36.       this.fieldColumns = new Object[this.fieldCount];
  37.    }
  38.  
  39.    public Archive archive() {
  40.       return this.archive;
  41.    }
  42.  
  43.    public String className() {
  44.       return this.className;
  45.    }
  46.  
  47.    public String[] classNames() {
  48.       return this.classNames;
  49.    }
  50.  
  51.    public int versionForClassName(String var1) {
  52.       int var3 = this.classCount;
  53.  
  54.       for(int var2 = 0; var2 < var3; ++var2) {
  55.          if (this.classNames[var2].equals(var1)) {
  56.             return this.classVersions[var2];
  57.          }
  58.       }
  59.  
  60.       return 0;
  61.    }
  62.  
  63.    public int rowCount() {
  64.       return this.rowCount;
  65.    }
  66.  
  67.    private Object newColumn(int var1, int var2) {
  68.       switch (var1) {
  69.          case 0:
  70.             return new boolean[var2];
  71.          case 1:
  72.             return new boolean[var2][];
  73.          case 2:
  74.             return new char[var2];
  75.          case 3:
  76.             return new char[var2][];
  77.          case 4:
  78.             return new byte[var2];
  79.          case 5:
  80.             return new byte[var2][];
  81.          case 6:
  82.             return new short[var2];
  83.          case 7:
  84.             return new short[var2][];
  85.          case 8:
  86.             return new int[var2];
  87.          case 9:
  88.             return new int[var2][];
  89.          case 10:
  90.             return new long[var2];
  91.          case 11:
  92.             return new long[var2][];
  93.          case 12:
  94.             return new float[var2];
  95.          case 13:
  96.             return new float[var2][];
  97.          case 14:
  98.             return new double[var2];
  99.          case 15:
  100.             return new double[var2][];
  101.          case 16:
  102.             return new String[var2];
  103.          case 17:
  104.             return new String[var2][];
  105.          case 18:
  106.             return new int[var2];
  107.          case 19:
  108.             return new int[var2][];
  109.          default:
  110.             throw new InconsistencyException("Unknown field type: " + var1);
  111.       }
  112.    }
  113.  
  114.    private void ensureCapacity(int var1) {
  115.       if (var1 > this.rowCapacity) {
  116.          for(int var2 = 0; var2 < this.fieldCount; ++var2) {
  117.             Object var3 = this.newColumn(this.fieldTypes[var2], var1);
  118.             if (this.rowCapacity > 0) {
  119.                System.arraycopy(this.fieldColumns[var2], 0, var3, 0, this.rowCapacity);
  120.             }
  121.  
  122.             this.fieldColumns[var2] = var3;
  123.          }
  124.  
  125.          this.rowCapacity = var1;
  126.       }
  127.    }
  128.  
  129.    private void growCapacity() {
  130.       int var1;
  131.       if (this.rowCapacity == 0) {
  132.          var1 = 8;
  133.       } else {
  134.          var1 = 2 * this.rowCapacity;
  135.       }
  136.  
  137.       this.ensureCapacity(var1);
  138.    }
  139.  
  140.    public int newIdentifier() {
  141.       if (this.rowCount >= this.rowCapacity) {
  142.          this.growCapacity();
  143.       }
  144.  
  145.       int var1 = this.archive.mapIdentifier(this, this.rowCount);
  146.       ++this.rowCount;
  147.       return var1;
  148.    }
  149.  
  150.    public int rowForIdentifier(int var1) {
  151.       return this.archive.rowForIdentifier(var1);
  152.    }
  153.  
  154.    public int columnForField(String var1) {
  155.       if (this.archive.performanceDebug) {
  156.          System.err.println("*** Field " + var1 + " of class " + this.className + " was accessed out of order.");
  157.       }
  158.  
  159.       if (this.columnForField == null) {
  160.          this.columnForField = new IdHashtable(true);
  161.  
  162.          for(int var2 = 0; var2 < this.fieldCount; ++var2) {
  163.             this.columnForField.putKnownAbsent(this.fieldNames[var2], var2 + 1);
  164.          }
  165.       }
  166.  
  167.       int var3 = this.columnForField.get(var1);
  168.       return var3 - 1;
  169.    }
  170.  
  171.    void uniqueStrings(ClassInfo var1) {
  172.       this.setUniqueStrings(true);
  173.       if (var1.fieldCount != this.fieldCount) {
  174.          if (this.archive.performanceDebug) {
  175.             System.err.println("Failed to unique Strings in class " + var1.className());
  176.          }
  177.  
  178.       } else {
  179.          this.columnForField = null;
  180.          String[] var4 = var1.fieldNames;
  181.          String[] var5 = this.fieldNames;
  182.          int var3 = this.fieldCount;
  183.  
  184.          for(int var2 = 0; var2 < var3; ++var2) {
  185.             if (!var5[var2].equals(var4[var2])) {
  186.                if (this.archive.performanceDebug) {
  187.                   System.err.println("Failed to unique Strings in class " + var1.className());
  188.                }
  189.  
  190.                return;
  191.             }
  192.  
  193.             var5[var2] = var4[var2];
  194.          }
  195.  
  196.          if (var1.classCount == this.classCount) {
  197.             var4 = var1.classNames;
  198.             var5 = this.classNames;
  199.             var3 = this.classCount;
  200.  
  201.             for(int var6 = 0; var6 < var3; ++var6) {
  202.                if (!var5[var6].equals(var4[var6])) {
  203.                   return;
  204.                }
  205.  
  206.                var5[var6] = var4[var6];
  207.             }
  208.  
  209.          }
  210.       }
  211.    }
  212.  
  213.    void setUniqueStrings(boolean var1) {
  214.       this.uniqueStrings = var1;
  215.    }
  216.  
  217.    boolean hasUniqueStrings() {
  218.       return this.uniqueStrings;
  219.    }
  220.  
  221.    public boolean booleanAt(int var1, int var2) {
  222.       if (var1 >= this.rowCount) {
  223.          throw new ArrayIndexOutOfBoundsException(var1);
  224.       } else {
  225.          return ((boolean[])this.fieldColumns[var2])[var1];
  226.       }
  227.    }
  228.  
  229.    public void setBooleanAt(int var1, int var2, boolean var3) {
  230.       if (var1 >= this.rowCount) {
  231.          throw new ArrayIndexOutOfBoundsException(var1);
  232.       } else {
  233.          ((boolean[])this.fieldColumns[var2])[var1] = var3;
  234.       }
  235.    }
  236.  
  237.    public boolean[] booleanArrayAt(int var1, int var2) {
  238.       if (var1 >= this.rowCount) {
  239.          throw new ArrayIndexOutOfBoundsException(var1);
  240.       } else {
  241.          return ((boolean[][])this.fieldColumns[var2])[var1];
  242.       }
  243.    }
  244.  
  245.    public void setBooleanArrayAt(int var1, int var2, boolean[] var3) {
  246.       if (var1 >= this.rowCount) {
  247.          throw new ArrayIndexOutOfBoundsException(var1);
  248.       } else {
  249.          ((boolean[][])this.fieldColumns[var2])[var1] = var3;
  250.       }
  251.    }
  252.  
  253.    public char charAt(int var1, int var2) {
  254.       if (var1 >= this.rowCount) {
  255.          throw new ArrayIndexOutOfBoundsException(var1);
  256.       } else {
  257.          return ((char[])this.fieldColumns[var2])[var1];
  258.       }
  259.    }
  260.  
  261.    public void setCharAt(int var1, int var2, char var3) {
  262.       if (var1 >= this.rowCount) {
  263.          throw new ArrayIndexOutOfBoundsException(var1);
  264.       } else {
  265.          ((char[])this.fieldColumns[var2])[var1] = var3;
  266.       }
  267.    }
  268.  
  269.    public char[] charArrayAt(int var1, int var2) {
  270.       if (var1 >= this.rowCount) {
  271.          throw new ArrayIndexOutOfBoundsException(var1);
  272.       } else {
  273.          return ((char[][])this.fieldColumns[var2])[var1];
  274.       }
  275.    }
  276.  
  277.    public void setCharArrayAt(int var1, int var2, char[] var3) {
  278.       if (var1 >= this.rowCount) {
  279.          throw new ArrayIndexOutOfBoundsException(var1);
  280.       } else {
  281.          ((char[][])this.fieldColumns[var2])[var1] = var3;
  282.       }
  283.    }
  284.  
  285.    public byte byteAt(int var1, int var2) {
  286.       if (var1 >= this.rowCount) {
  287.          throw new ArrayIndexOutOfBoundsException(var1);
  288.       } else {
  289.          return ((byte[])this.fieldColumns[var2])[var1];
  290.       }
  291.    }
  292.  
  293.    public void setByteAt(int var1, int var2, byte var3) {
  294.       if (var1 >= this.rowCount) {
  295.          throw new ArrayIndexOutOfBoundsException(var1);
  296.       } else {
  297.          ((byte[])this.fieldColumns[var2])[var1] = var3;
  298.       }
  299.    }
  300.  
  301.    public byte[] byteArrayAt(int var1, int var2) {
  302.       if (var1 >= this.rowCount) {
  303.          throw new ArrayIndexOutOfBoundsException(var1);
  304.       } else {
  305.          return ((byte[][])this.fieldColumns[var2])[var1];
  306.       }
  307.    }
  308.  
  309.    public void setByteArrayAt(int var1, int var2, byte[] var3) {
  310.       if (var1 >= this.rowCount) {
  311.          throw new ArrayIndexOutOfBoundsException(var1);
  312.       } else {
  313.          ((byte[][])this.fieldColumns[var2])[var1] = var3;
  314.       }
  315.    }
  316.  
  317.    public short shortAt(int var1, int var2) {
  318.       if (var1 >= this.rowCount) {
  319.          throw new ArrayIndexOutOfBoundsException(var1);
  320.       } else {
  321.          return ((short[])this.fieldColumns[var2])[var1];
  322.       }
  323.    }
  324.  
  325.    public void setShortAt(int var1, int var2, short var3) {
  326.       if (var1 >= this.rowCount) {
  327.          throw new ArrayIndexOutOfBoundsException(var1);
  328.       } else {
  329.          ((short[])this.fieldColumns[var2])[var1] = var3;
  330.       }
  331.    }
  332.  
  333.    public short[] shortArrayAt(int var1, int var2) {
  334.       if (var1 >= this.rowCount) {
  335.          throw new ArrayIndexOutOfBoundsException(var1);
  336.       } else {
  337.          return ((short[][])this.fieldColumns[var2])[var1];
  338.       }
  339.    }
  340.  
  341.    public void setShortArrayAt(int var1, int var2, short[] var3) {
  342.       if (var1 >= this.rowCount) {
  343.          throw new ArrayIndexOutOfBoundsException(var1);
  344.       } else {
  345.          ((short[][])this.fieldColumns[var2])[var1] = var3;
  346.       }
  347.    }
  348.  
  349.    public int intAt(int var1, int var2) {
  350.       if (var1 >= this.rowCount) {
  351.          throw new ArrayIndexOutOfBoundsException(var1);
  352.       } else {
  353.          return ((int[])this.fieldColumns[var2])[var1];
  354.       }
  355.    }
  356.  
  357.    public void setIntAt(int var1, int var2, int var3) {
  358.       if (var1 >= this.rowCount) {
  359.          throw new ArrayIndexOutOfBoundsException(var1);
  360.       } else {
  361.          ((int[])this.fieldColumns[var2])[var1] = var3;
  362.       }
  363.    }
  364.  
  365.    public int[] intArrayAt(int var1, int var2) {
  366.       if (var1 >= this.rowCount) {
  367.          throw new ArrayIndexOutOfBoundsException(var1);
  368.       } else {
  369.          return ((int[][])this.fieldColumns[var2])[var1];
  370.       }
  371.    }
  372.  
  373.    public void setIntArrayAt(int var1, int var2, int[] var3) {
  374.       if (var1 >= this.rowCount) {
  375.          throw new ArrayIndexOutOfBoundsException(var1);
  376.       } else {
  377.          ((int[][])this.fieldColumns[var2])[var1] = var3;
  378.       }
  379.    }
  380.  
  381.    public long longAt(int var1, int var2) {
  382.       if (var1 >= this.rowCount) {
  383.          throw new ArrayIndexOutOfBoundsException(var1);
  384.       } else {
  385.          return ((long[])this.fieldColumns[var2])[var1];
  386.       }
  387.    }
  388.  
  389.    public void setLongAt(int var1, int var2, long var3) {
  390.       if (var1 >= this.rowCount) {
  391.          throw new ArrayIndexOutOfBoundsException(var1);
  392.       } else {
  393.          ((long[])this.fieldColumns[var2])[var1] = var3;
  394.       }
  395.    }
  396.  
  397.    public long[] longArrayAt(int var1, int var2) {
  398.       if (var1 >= this.rowCount) {
  399.          throw new ArrayIndexOutOfBoundsException(var1);
  400.       } else {
  401.          return ((long[][])this.fieldColumns[var2])[var1];
  402.       }
  403.    }
  404.  
  405.    public void setLongArrayAt(int var1, int var2, long[] var3) {
  406.       if (var1 >= this.rowCount) {
  407.          throw new ArrayIndexOutOfBoundsException(var1);
  408.       } else {
  409.          ((long[][])this.fieldColumns[var2])[var1] = var3;
  410.       }
  411.    }
  412.  
  413.    public float floatAt(int var1, int var2) {
  414.       if (var1 >= this.rowCount) {
  415.          throw new ArrayIndexOutOfBoundsException(var1);
  416.       } else {
  417.          return ((float[])this.fieldColumns[var2])[var1];
  418.       }
  419.    }
  420.  
  421.    public void setFloatAt(int var1, int var2, float var3) {
  422.       if (var1 >= this.rowCount) {
  423.          throw new ArrayIndexOutOfBoundsException(var1);
  424.       } else {
  425.          ((float[])this.fieldColumns[var2])[var1] = var3;
  426.       }
  427.    }
  428.  
  429.    public float[] floatArrayAt(int var1, int var2) {
  430.       if (var1 >= this.rowCount) {
  431.          throw new ArrayIndexOutOfBoundsException(var1);
  432.       } else {
  433.          return ((float[][])this.fieldColumns[var2])[var1];
  434.       }
  435.    }
  436.  
  437.    public void setFloatArrayAt(int var1, int var2, float[] var3) {
  438.       if (var1 >= this.rowCount) {
  439.          throw new ArrayIndexOutOfBoundsException(var1);
  440.       } else {
  441.          ((float[][])this.fieldColumns[var2])[var1] = var3;
  442.       }
  443.    }
  444.  
  445.    public double doubleAt(int var1, int var2) {
  446.       if (var1 >= this.rowCount) {
  447.          throw new ArrayIndexOutOfBoundsException(var1);
  448.       } else {
  449.          return ((double[])this.fieldColumns[var2])[var1];
  450.       }
  451.    }
  452.  
  453.    public void setDoubleAt(int var1, int var2, double var3) {
  454.       if (var1 >= this.rowCount) {
  455.          throw new ArrayIndexOutOfBoundsException(var1);
  456.       } else {
  457.          ((double[])this.fieldColumns[var2])[var1] = var3;
  458.       }
  459.    }
  460.  
  461.    public double[] doubleArrayAt(int var1, int var2) {
  462.       if (var1 >= this.rowCount) {
  463.          throw new ArrayIndexOutOfBoundsException(var1);
  464.       } else {
  465.          return ((double[][])this.fieldColumns[var2])[var1];
  466.       }
  467.    }
  468.  
  469.    public void setDoubleArrayAt(int var1, int var2, double[] var3) {
  470.       if (var1 >= this.rowCount) {
  471.          throw new ArrayIndexOutOfBoundsException(var1);
  472.       } else {
  473.          ((double[][])this.fieldColumns[var2])[var1] = var3;
  474.       }
  475.    }
  476.  
  477.    public String stringAt(int var1, int var2) {
  478.       if (var1 >= this.rowCount) {
  479.          throw new ArrayIndexOutOfBoundsException(var1);
  480.       } else {
  481.          return ((String[])this.fieldColumns[var2])[var1];
  482.       }
  483.    }
  484.  
  485.    public void setStringAt(int var1, int var2, String var3) {
  486.       if (var1 >= this.rowCount) {
  487.          throw new ArrayIndexOutOfBoundsException(var1);
  488.       } else {
  489.          ((String[])this.fieldColumns[var2])[var1] = var3;
  490.       }
  491.    }
  492.  
  493.    public String[] stringArrayAt(int var1, int var2) {
  494.       if (var1 >= this.rowCount) {
  495.          throw new ArrayIndexOutOfBoundsException(var1);
  496.       } else {
  497.          return ((String[][])this.fieldColumns[var2])[var1];
  498.       }
  499.    }
  500.  
  501.    public void setStringArrayAt(int var1, int var2, String[] var3) {
  502.       if (var1 >= this.rowCount) {
  503.          throw new ArrayIndexOutOfBoundsException(var1);
  504.       } else {
  505.          ((String[][])this.fieldColumns[var2])[var1] = var3;
  506.       }
  507.    }
  508.  
  509.    public int identifierAt(int var1, int var2) {
  510.       if (var1 >= this.rowCount) {
  511.          throw new ArrayIndexOutOfBoundsException(var1);
  512.       } else {
  513.          return ((int[])this.fieldColumns[var2])[var1];
  514.       }
  515.    }
  516.  
  517.    public void setIdentifierAt(int var1, int var2, int var3) {
  518.       if (var1 >= this.rowCount) {
  519.          throw new ArrayIndexOutOfBoundsException(var1);
  520.       } else {
  521.          ((int[])this.fieldColumns[var2])[var1] = var3;
  522.       }
  523.    }
  524.  
  525.    public int[] identifierArrayAt(int var1, int var2) {
  526.       if (var1 >= this.rowCount) {
  527.          throw new ArrayIndexOutOfBoundsException(var1);
  528.       } else {
  529.          return ((int[][])this.fieldColumns[var2])[var1];
  530.       }
  531.    }
  532.  
  533.    public void setIdentifierArrayAt(int var1, int var2, int[] var3) {
  534.       if (var1 >= this.rowCount) {
  535.          throw new ArrayIndexOutOfBoundsException(var1);
  536.       } else {
  537.          ((int[][])this.fieldColumns[var2])[var1] = var3;
  538.       }
  539.    }
  540.  
  541.    public void writeInfo(OutputStream var1) throws IOException {
  542.       CompactOutputStream var4;
  543.       if (var1 instanceof CompactOutputStream) {
  544.          var4 = (CompactOutputStream)var1;
  545.       } else {
  546.          var4 = new CompactOutputStream(var1);
  547.       }
  548.  
  549.       var4.writeCompactUTF(this.className);
  550.       int var3 = this.fieldCount;
  551.       var4.writeCompactInt(var3);
  552.  
  553.       for(int var2 = 0; var2 < var3; ++var2) {
  554.          var4.writeCompactUTF(this.fieldNames[var2]);
  555.          var4.writeByte(this.fieldTypes[var2]);
  556.       }
  557.  
  558.       var3 = this.classCount;
  559.       var4.writeCompactInt(var3);
  560.  
  561.       for(int var5 = 0; var5 < var3; ++var5) {
  562.          var4.writeCompactUTF(this.classNames[var5]);
  563.          var4.writeCompactInt(this.classVersions[var5]);
  564.       }
  565.  
  566.       var4.writeCompactInt(0);
  567.    }
  568.  
  569.    public void writeData(OutputStream var1) throws IOException {
  570.       CompactOutputStream var5;
  571.       if (var1 instanceof CompactOutputStream) {
  572.          var5 = (CompactOutputStream)var1;
  573.       } else {
  574.          var5 = new CompactOutputStream(var1);
  575.       }
  576.  
  577.       var5.writeCompactInt(this.rowCount);
  578.       int var3 = this.fieldCount;
  579.  
  580.       for(int var2 = 0; var2 < var3; ++var2) {
  581.          if (this.fieldTypes[var2] == 0) {
  582.             this.writeBooleanColumn(var5, (boolean[])this.fieldColumns[var2], this.rowCount);
  583.          }
  584.       }
  585.  
  586.       for(int var6 = 0; var6 < var3; ++var6) {
  587.          Object var4 = this.fieldColumns[var6];
  588.          switch (this.fieldTypes[var6]) {
  589.             case 0:
  590.                break;
  591.             case 1:
  592.                this.writeBooleanArrayColumn(var5, (boolean[][])var4, this.rowCount);
  593.                break;
  594.             case 2:
  595.                this.writeCharColumn(var5, (char[])var4, this.rowCount);
  596.                break;
  597.             case 3:
  598.                this.writeCharArrayColumn(var5, (char[][])var4, this.rowCount);
  599.                break;
  600.             case 4:
  601.                this.writeByteColumn(var5, (byte[])var4, this.rowCount);
  602.                break;
  603.             case 5:
  604.                this.writeByteArrayColumn(var5, (byte[][])var4, this.rowCount);
  605.                break;
  606.             case 6:
  607.                this.writeShortColumn(var5, (short[])var4, this.rowCount);
  608.                break;
  609.             case 7:
  610.                this.writeShortArrayColumn(var5, (short[][])var4, this.rowCount);
  611.                break;
  612.             case 8:
  613.                this.writeIntColumn(var5, (int[])var4, this.rowCount);
  614.                break;
  615.             case 9:
  616.                this.writeIntArrayColumn(var5, (int[][])var4, this.rowCount);
  617.                break;
  618.             case 10:
  619.                this.writeLongColumn(var5, (long[])var4, this.rowCount);
  620.                break;
  621.             case 11:
  622.                this.writeLongArrayColumn(var5, (long[][])var4, this.rowCount);
  623.                break;
  624.             case 12:
  625.                this.writeFloatColumn(var5, (float[])var4, this.rowCount);
  626.                break;
  627.             case 13:
  628.                this.writeFloatArrayColumn(var5, (float[][])var4, this.rowCount);
  629.                break;
  630.             case 14:
  631.                this.writeDoubleColumn(var5, (double[])var4, this.rowCount);
  632.                break;
  633.             case 15:
  634.                this.writeDoubleArrayColumn(var5, (double[][])var4, this.rowCount);
  635.                break;
  636.             case 16:
  637.                this.writeStringColumn(var5, (String[])var4, this.rowCount);
  638.                break;
  639.             case 17:
  640.                this.writeStringArrayColumn(var5, (String[][])var4, this.rowCount);
  641.                break;
  642.             case 18:
  643.                this.writeIntColumn(var5, (int[])var4, this.rowCount);
  644.                break;
  645.             case 19:
  646.                this.writeIntArrayColumn(var5, (int[][])var4, this.rowCount);
  647.                break;
  648.             default:
  649.                throw new InconsistencyException("Unknown field type: " + this.fieldTypes[var6]);
  650.          }
  651.       }
  652.  
  653.       var5.writeCompactInt(0);
  654.    }
  655.  
  656.    private void writeBooleanColumn(CompactOutputStream var1, boolean[] var2, int var3) throws IOException {
  657.       for(int var4 = 0; var4 < var3; ++var4) {
  658.          var1.writeCompactBoolean(var2[var4]);
  659.       }
  660.  
  661.    }
  662.  
  663.    private void writeBooleanArrayColumn(CompactOutputStream var1, boolean[][] var2, int var3) throws IOException {
  664.       for(int var4 = 0; var4 < var3; ++var4) {
  665.          boolean[] var5 = var2[var4];
  666.          if (var5 == null) {
  667.             var1.writeCompactInt(-1);
  668.          } else {
  669.             var1.writeCompactInt(var5.length);
  670.             this.writeBooleanColumn(var1, var5, var5.length);
  671.          }
  672.       }
  673.  
  674.    }
  675.  
  676.    private void writeCharColumn(CompactOutputStream var1, char[] var2, int var3) throws IOException {
  677.       for(int var4 = 0; var4 < var3; ++var4) {
  678.          var1.writeChar(var2[var4]);
  679.       }
  680.  
  681.    }
  682.  
  683.    private void writeCharArrayColumn(CompactOutputStream var1, char[][] var2, int var3) throws IOException {
  684.       for(int var4 = 0; var4 < var3; ++var4) {
  685.          char[] var5 = var2[var4];
  686.          if (var5 == null) {
  687.             var1.writeCompactInt(-1);
  688.          } else {
  689.             var1.writeCompactInt(var5.length);
  690.             this.writeCharColumn(var1, var5, var5.length);
  691.          }
  692.       }
  693.  
  694.    }
  695.  
  696.    private void writeByteColumn(CompactOutputStream var1, byte[] var2, int var3) throws IOException {
  697.       var1.write(var2, 0, var3);
  698.    }
  699.  
  700.    private void writeByteArrayColumn(CompactOutputStream var1, byte[][] var2, int var3) throws IOException {
  701.       for(int var4 = 0; var4 < var3; ++var4) {
  702.          byte[] var5 = var2[var4];
  703.          if (var5 == null) {
  704.             var1.writeCompactInt(-1);
  705.          } else {
  706.             var1.writeCompactInt(var5.length);
  707.             this.writeByteColumn(var1, var5, var5.length);
  708.          }
  709.       }
  710.  
  711.    }
  712.  
  713.    private void writeShortColumn(CompactOutputStream var1, short[] var2, int var3) throws IOException {
  714.       for(int var4 = 0; var4 < var3; ++var4) {
  715.          var1.writeShort(var2[var4]);
  716.       }
  717.  
  718.    }
  719.  
  720.    private void writeShortArrayColumn(CompactOutputStream var1, short[][] var2, int var3) throws IOException {
  721.       for(int var4 = 0; var4 < var3; ++var4) {
  722.          short[] var5 = var2[var4];
  723.          if (var5 == null) {
  724.             var1.writeCompactInt(-1);
  725.          } else {
  726.             var1.writeCompactInt(var5.length);
  727.             this.writeShortColumn(var1, var5, var5.length);
  728.          }
  729.       }
  730.  
  731.    }
  732.  
  733.    private void writeIntColumn(CompactOutputStream var1, int[] var2, int var3) throws IOException {
  734.       for(int var4 = 0; var4 < var3; ++var4) {
  735.          var1.writeCompactInt(var2[var4]);
  736.       }
  737.  
  738.    }
  739.  
  740.    private void writeIntArrayColumn(CompactOutputStream var1, int[][] var2, int var3) throws IOException {
  741.       for(int var4 = 0; var4 < var3; ++var4) {
  742.          int[] var7 = var2[var4];
  743.          if (var7 == null) {
  744.             var1.writeCompactInt(-1);
  745.          } else {
  746.             int var6 = var7.length;
  747.             var1.writeCompactInt(var6);
  748.  
  749.             for(int var5 = 0; var5 < var6; ++var5) {
  750.                var1.writeInt(var7[var5]);
  751.             }
  752.          }
  753.       }
  754.  
  755.    }
  756.  
  757.    private void writeLongColumn(CompactOutputStream var1, long[] var2, int var3) throws IOException {
  758.       for(int var4 = 0; var4 < var3; ++var4) {
  759.          var1.writeLong(var2[var4]);
  760.       }
  761.  
  762.    }
  763.  
  764.    private void writeLongArrayColumn(CompactOutputStream var1, long[][] var2, int var3) throws IOException {
  765.       for(int var4 = 0; var4 < var3; ++var4) {
  766.          long[] var5 = var2[var4];
  767.          if (var5 == null) {
  768.             var1.writeCompactInt(-1);
  769.          } else {
  770.             var1.writeCompactInt(var5.length);
  771.             this.writeLongColumn(var1, var5, var5.length);
  772.          }
  773.       }
  774.  
  775.    }
  776.  
  777.    private void writeFloatColumn(CompactOutputStream var1, float[] var2, int var3) throws IOException {
  778.       for(int var4 = 0; var4 < var3; ++var4) {
  779.          var1.writeFloat(var2[var4]);
  780.       }
  781.  
  782.    }
  783.  
  784.    private void writeFloatArrayColumn(CompactOutputStream var1, float[][] var2, int var3) throws IOException {
  785.       for(int var4 = 0; var4 < var3; ++var4) {
  786.          float[] var5 = var2[var4];
  787.          if (var5 == null) {
  788.             var1.writeCompactInt(-1);
  789.          } else {
  790.             var1.writeCompactInt(var5.length);
  791.             this.writeFloatColumn(var1, var5, var5.length);
  792.          }
  793.       }
  794.  
  795.    }
  796.  
  797.    private void writeDoubleColumn(CompactOutputStream var1, double[] var2, int var3) throws IOException {
  798.       for(int var4 = 0; var4 < var3; ++var4) {
  799.          var1.writeDouble(var2[var4]);
  800.       }
  801.  
  802.    }
  803.  
  804.    private void writeDoubleArrayColumn(CompactOutputStream var1, double[][] var2, int var3) throws IOException {
  805.       for(int var4 = 0; var4 < var3; ++var4) {
  806.          double[] var5 = var2[var4];
  807.          if (var5 == null) {
  808.             var1.writeCompactInt(-1);
  809.          } else {
  810.             var1.writeCompactInt(var5.length);
  811.             this.writeDoubleColumn(var1, var5, var5.length);
  812.          }
  813.       }
  814.  
  815.    }
  816.  
  817.    private void writeStringColumn(CompactOutputStream var1, String[] var2, int var3) throws IOException {
  818.       for(int var4 = 0; var4 < var3; ++var4) {
  819.          var1.writeCompactUTF(var2[var4]);
  820.       }
  821.  
  822.    }
  823.  
  824.    private void writeStringArrayColumn(CompactOutputStream var1, String[][] var2, int var3) throws IOException {
  825.       for(int var4 = 0; var4 < var3; ++var4) {
  826.          String[] var5 = var2[var4];
  827.          if (var5 == null) {
  828.             var1.writeCompactInt(-1);
  829.          } else {
  830.             var1.writeCompactInt(var5.length);
  831.             this.writeStringColumn(var1, var5, var5.length);
  832.          }
  833.       }
  834.  
  835.    }
  836.  
  837.    public void readInfo(InputStream var1) throws IOException {
  838.       CompactInputStream var4;
  839.       if (var1 instanceof CompactInputStream) {
  840.          var4 = (CompactInputStream)var1;
  841.       } else {
  842.          var4 = new CompactInputStream(var1);
  843.       }
  844.  
  845.       this.className = var4.readCompactUTF();
  846.       int var3 = var4.readCompactInt();
  847.       this.fieldCount = var3;
  848.       this.fieldNames = new String[var3];
  849.       this.fieldTypes = new byte[var3];
  850.       this.fieldColumns = new Object[var3];
  851.  
  852.       for(int var2 = 0; var2 < var3; ++var2) {
  853.          this.fieldNames[var2] = var4.readCompactUTF();
  854.          this.fieldTypes[var2] = var4.readByte();
  855.       }
  856.  
  857.       var3 = var4.readCompactInt();
  858.       this.classCount = var3;
  859.       this.classNames = new String[var3];
  860.       this.classVersions = new int[var3];
  861.  
  862.       for(int var5 = 0; var5 < var3; ++var5) {
  863.          this.classNames[var5] = var4.readCompactUTF();
  864.          this.classVersions[var5] = var4.readCompactInt();
  865.       }
  866.  
  867.       var3 = var4.readCompactInt();
  868.       if (var3 > 0) {
  869.          var4.skipBytes(var3);
  870.       }
  871.  
  872.    }
  873.  
  874.    public void readData(InputStream var1) throws IOException {
  875.       CompactInputStream var5;
  876.       if (var1 instanceof CompactInputStream) {
  877.          var5 = (CompactInputStream)var1;
  878.       } else {
  879.          var5 = new CompactInputStream(var1);
  880.       }
  881.  
  882.       this.rowCount = var5.readCompactInt();
  883.       this.ensureCapacity(this.rowCount);
  884.       int var3 = this.fieldCount;
  885.  
  886.       for(int var2 = 0; var2 < var3; ++var2) {
  887.          if (this.fieldTypes[var2] == 0) {
  888.             this.readBooleanColumn(var5, (boolean[])this.fieldColumns[var2], this.rowCount);
  889.          }
  890.       }
  891.  
  892.       for(int var6 = 0; var6 < var3; ++var6) {
  893.          Object var4 = this.fieldColumns[var6];
  894.          switch (this.fieldTypes[var6]) {
  895.             case 0:
  896.                break;
  897.             case 1:
  898.                this.readBooleanArrayColumn(var5, (boolean[][])var4, this.rowCount);
  899.                break;
  900.             case 2:
  901.                this.readCharColumn(var5, (char[])var4, this.rowCount);
  902.                break;
  903.             case 3:
  904.                this.readCharArrayColumn(var5, (char[][])var4, this.rowCount);
  905.                break;
  906.             case 4:
  907.                this.readByteColumn(var5, (byte[])var4, this.rowCount);
  908.                break;
  909.             case 5:
  910.                this.readByteArrayColumn(var5, (byte[][])var4, this.rowCount);
  911.                break;
  912.             case 6:
  913.                this.readShortColumn(var5, (short[])var4, this.rowCount);
  914.                break;
  915.             case 7:
  916.                this.readShortArrayColumn(var5, (short[][])var4, this.rowCount);
  917.                break;
  918.             case 8:
  919.                this.readIntColumn(var5, (int[])var4, this.rowCount);
  920.                break;
  921.             case 9:
  922.                this.readIntArrayColumn(var5, (int[][])var4, this.rowCount);
  923.                break;
  924.             case 10:
  925.                this.readLongColumn(var5, (long[])var4, this.rowCount);
  926.                break;
  927.             case 11:
  928.                this.readLongArrayColumn(var5, (long[][])var4, this.rowCount);
  929.                break;
  930.             case 12:
  931.                this.readFloatColumn(var5, (float[])var4, this.rowCount);
  932.                break;
  933.             case 13:
  934.                this.readFloatArrayColumn(var5, (float[][])var4, this.rowCount);
  935.                break;
  936.             case 14:
  937.                this.readDoubleColumn(var5, (double[])var4, this.rowCount);
  938.                break;
  939.             case 15:
  940.                this.readDoubleArrayColumn(var5, (double[][])var4, this.rowCount);
  941.                break;
  942.             case 16:
  943.                this.readStringColumn(var5, (String[])var4, this.rowCount);
  944.                break;
  945.             case 17:
  946.                this.readStringArrayColumn(var5, (String[][])var4, this.rowCount);
  947.                break;
  948.             case 18:
  949.                this.readIntColumn(var5, (int[])var4, this.rowCount);
  950.                break;
  951.             case 19:
  952.                this.readIntArrayColumn(var5, (int[][])var4, this.rowCount);
  953.                break;
  954.             default:
  955.                throw new InconsistencyException("Unknown field type: " + this.fieldTypes[var6]);
  956.          }
  957.       }
  958.  
  959.       var3 = var5.readCompactInt();
  960.       if (var3 > 0) {
  961.          var5.skipBytes(var3);
  962.       }
  963.  
  964.    }
  965.  
  966.    private void readBooleanColumn(CompactInputStream var1, boolean[] var2, int var3) throws IOException {
  967.       for(int var4 = 0; var4 < var3; ++var4) {
  968.          var2[var4] = var1.readCompactBoolean();
  969.       }
  970.  
  971.    }
  972.  
  973.    private void readBooleanArrayColumn(CompactInputStream var1, boolean[][] var2, int var3) throws IOException {
  974.       for(int var4 = 0; var4 < var3; ++var4) {
  975.          int var5 = var1.readCompactInt();
  976.          if (var5 >= 0) {
  977.             boolean[] var6 = new boolean[var5];
  978.             var2[var4] = var6;
  979.             this.readBooleanColumn(var1, var6, var5);
  980.          }
  981.       }
  982.  
  983.    }
  984.  
  985.    private void readCharColumn(CompactInputStream var1, char[] var2, int var3) throws IOException {
  986.       for(int var4 = 0; var4 < var3; ++var4) {
  987.          var2[var4] = var1.readChar();
  988.       }
  989.  
  990.    }
  991.  
  992.    private void readCharArrayColumn(CompactInputStream var1, char[][] var2, int var3) throws IOException {
  993.       for(int var4 = 0; var4 < var3; ++var4) {
  994.          int var5 = var1.readCompactInt();
  995.          if (var5 >= 0) {
  996.             char[] var6 = new char[var5];
  997.             var2[var4] = var6;
  998.             this.readCharColumn(var1, var6, var5);
  999.          }
  1000.       }
  1001.  
  1002.    }
  1003.  
  1004.    private void readByteColumn(CompactInputStream var1, byte[] var2, int var3) throws IOException {
  1005.       var1.readFully(var2, 0, var3);
  1006.    }
  1007.  
  1008.    private void readByteArrayColumn(CompactInputStream var1, byte[][] var2, int var3) throws IOException {
  1009.       for(int var4 = 0; var4 < var3; ++var4) {
  1010.          int var5 = var1.readCompactInt();
  1011.          if (var5 >= 0) {
  1012.             byte[] var6 = new byte[var5];
  1013.             var2[var4] = var6;
  1014.             this.readByteColumn(var1, var6, var5);
  1015.          }
  1016.       }
  1017.  
  1018.    }
  1019.  
  1020.    private void readShortColumn(CompactInputStream var1, short[] var2, int var3) throws IOException {
  1021.       for(int var4 = 0; var4 < var3; ++var4) {
  1022.          var2[var4] = var1.readShort();
  1023.       }
  1024.  
  1025.    }
  1026.  
  1027.    private void readShortArrayColumn(CompactInputStream var1, short[][] var2, int var3) throws IOException {
  1028.       for(int var4 = 0; var4 < var3; ++var4) {
  1029.          int var5 = var1.readCompactInt();
  1030.          if (var5 >= 0) {
  1031.             short[] var6 = new short[var5];
  1032.             var2[var4] = var6;
  1033.             this.readShortColumn(var1, var6, var5);
  1034.          }
  1035.       }
  1036.  
  1037.    }
  1038.  
  1039.    private void readIntColumn(CompactInputStream var1, int[] var2, int var3) throws IOException {
  1040.       for(int var4 = 0; var4 < var3; ++var4) {
  1041.          var2[var4] = var1.readCompactInt();
  1042.       }
  1043.  
  1044.    }
  1045.  
  1046.    private void readIntArrayColumn(CompactInputStream var1, int[][] var2, int var3) throws IOException {
  1047.       for(int var4 = 0; var4 < var3; ++var4) {
  1048.          int var6 = var1.readCompactInt();
  1049.          if (var6 >= 0) {
  1050.             int[] var7 = new int[var6];
  1051.             var2[var4] = var7;
  1052.  
  1053.             for(int var5 = 0; var5 < var6; ++var5) {
  1054.                var7[var5] = var1.readInt();
  1055.             }
  1056.          }
  1057.       }
  1058.  
  1059.    }
  1060.  
  1061.    private void readLongColumn(CompactInputStream var1, long[] var2, int var3) throws IOException {
  1062.       for(int var4 = 0; var4 < var3; ++var4) {
  1063.          var2[var4] = var1.readLong();
  1064.       }
  1065.  
  1066.    }
  1067.  
  1068.    private void readLongArrayColumn(CompactInputStream var1, long[][] var2, int var3) throws IOException {
  1069.       for(int var4 = 0; var4 < var3; ++var4) {
  1070.          int var5 = var1.readCompactInt();
  1071.          if (var5 >= 0) {
  1072.             long[] var6 = new long[var5];
  1073.             var2[var4] = var6;
  1074.             this.readLongColumn(var1, var6, var5);
  1075.          }
  1076.       }
  1077.  
  1078.    }
  1079.  
  1080.    private void readFloatColumn(CompactInputStream var1, float[] var2, int var3) throws IOException {
  1081.       for(int var4 = 0; var4 < var3; ++var4) {
  1082.          var2[var4] = var1.readFloat();
  1083.       }
  1084.  
  1085.    }
  1086.  
  1087.    private void readFloatArrayColumn(CompactInputStream var1, float[][] var2, int var3) throws IOException {
  1088.       for(int var4 = 0; var4 < var3; ++var4) {
  1089.          int var5 = var1.readCompactInt();
  1090.          if (var5 >= 0) {
  1091.             float[] var6 = new float[var5];
  1092.             var2[var4] = var6;
  1093.             this.readFloatColumn(var1, var6, var5);
  1094.          }
  1095.       }
  1096.  
  1097.    }
  1098.  
  1099.    private void readDoubleColumn(CompactInputStream var1, double[] var2, int var3) throws IOException {
  1100.       for(int var4 = 0; var4 < var3; ++var4) {
  1101.          var2[var4] = var1.readDouble();
  1102.       }
  1103.  
  1104.    }
  1105.  
  1106.    private void readDoubleArrayColumn(CompactInputStream var1, double[][] var2, int var3) throws IOException {
  1107.       for(int var4 = 0; var4 < var3; ++var4) {
  1108.          int var5 = var1.readCompactInt();
  1109.          if (var5 >= 0) {
  1110.             double[] var6 = new double[var5];
  1111.             var2[var4] = var6;
  1112.             this.readDoubleColumn(var1, var6, var5);
  1113.          }
  1114.       }
  1115.  
  1116.    }
  1117.  
  1118.    private void readStringColumn(CompactInputStream var1, String[] var2, int var3) throws IOException {
  1119.       for(int var4 = 0; var4 < var3; ++var4) {
  1120.          var2[var4] = var1.readCompactUTF();
  1121.       }
  1122.  
  1123.    }
  1124.  
  1125.    private void readStringArrayColumn(CompactInputStream var1, String[][] var2, int var3) throws IOException {
  1126.       for(int var4 = 0; var4 < var3; ++var4) {
  1127.          int var5 = var1.readCompactInt();
  1128.          if (var5 >= 0) {
  1129.             String[] var6 = new String[var5];
  1130.             var2[var4] = var6;
  1131.             this.readStringColumn(var1, var6, var5);
  1132.          }
  1133.       }
  1134.  
  1135.    }
  1136. }
  1137.